home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / xwindows / demos / xfract_1.z / xfract_1 / xfractint-1.06 / parser.c < prev    next >
C/C++ Source or Header  |  1992-09-28  |  53KB  |  2,172 lines
  1. /* Parser.c (C) 1990, Mark C. Peterson, CompuServe [70441,3353]
  2.      All rights reserved.
  3.  
  4.    Code may be used in any program provided the author is credited
  5.      either during program execution or in the documentation.  Source
  6.      code may be distributed only in combination with public domain or
  7.      shareware source code.  Source code may be modified provided the
  8.      copyright notice and this message is left unchanged and all
  9.      modifications are clearly documented.
  10.  
  11.      I would appreciate a copy of any work which incorporates this code,
  12.      however this is optional.
  13.  
  14.      Mark C. Peterson
  15.      405-C Queen St. Suite #181
  16.      Southington, CT 06489
  17.      (203) 276-9721
  18. */
  19.  
  20. #include <string.h>
  21. #include <ctype.h>
  22. #include <stdio.h>
  23. #include <stdlib.h>
  24. #include <float.h>                              /* TIW 04-22-91 */
  25. #include <time.h>
  26. #include "mpmath.h"
  27. #include "prototyp.h"
  28.  
  29. extern int Transparent3D;                         /* MCP 5-30-91 */
  30.  
  31. #ifdef WATCH_MP
  32. double x1, y1, x2, y2;
  33. #endif
  34.  
  35. MATH_TYPE MathType = D_MATH;
  36. /* moved struct lcomplex and union ARg to mpmath.h -6-20-90 TIW */
  37.  
  38. /* PB 910417 added MAX_OPS and MAX_ARGS defines */
  39. #define MAX_ARGS 100
  40. struct ConstArg {
  41.    char *s;
  42.    int len;
  43.    union Arg a;
  44. };
  45.  
  46. #define MAX_OPS 250
  47. struct PEND_OP {
  48.    void (far *f)(void);
  49.    int p;
  50. };
  51.  
  52. /* PB 901103 made some of the following static for safety */
  53. static struct PEND_OP far *o;
  54.  
  55. static void parser_allocate(void);
  56.  
  57. union Arg *Arg1, *Arg2;
  58. /* PB 910417 removed unused "a" array */
  59. static union Arg s[20], far * far *Store, far * far *Load;
  60. static int StoPtr, LodPtr, OpPtr;
  61.  
  62. static void (far * far *f)(void) = (void(far * far *)(void))0;
  63.  
  64. static unsigned n, ErrPtr, posp, vsp, NextOp, LastOp, InitN;
  65. static int paren, SyntaxErr, ExpectingArg;
  66. static struct ConstArg far *v = (struct ConstArg far *)0;
  67. static int InitLodPtr, InitStoPtr, InitOpPtr, LastInitOp;
  68.  static int Delta16;
  69. double fgLimit;           /* TIW 05-04-91 */
  70. static double fg;
  71. static int ShiftBack;     /* TIW 06-18-90 */
  72. static int SetRandom;     /* MCP 11-21-91 */
  73. static int Randomized;
  74. static unsigned long RandNum;
  75.  
  76. extern int bitshift;
  77. extern int bitshiftless1;
  78. extern int symmetry;          /* symmetry flag for calcmand()  */
  79. extern double param[];
  80.  
  81. extern int debugflag;         /* BDT for debugging */
  82. extern char boxx[8192];       /* PB 4-9-91, good place for the formula string */
  83. extern int row, col, overflow, cpu, fpu;
  84. extern struct complex old, new;
  85. extern double far *dx0, far *dy0;
  86. extern long far *lx0, far *ly0;     /* BDT moved these to FAR */
  87.  
  88. #ifndef TESTING_MATH
  89.    extern double far *dx1, far *dy1;
  90.    extern long far *lx1, far *ly1;
  91. #define dShiftx dx1[row]
  92. #define dShifty dy1[col]
  93. #define lShiftx lx1[row]
  94. #define lShifty ly1[col]
  95. #else
  96. #define dShiftx 0.0
  97. #define dShifty 0.0
  98. #define lShiftx 0L
  99. #define lShifty 0L
  100. #endif
  101.  
  102. extern struct lcomplex lold, lnew;
  103. extern char FormName[];
  104.  
  105. extern VOIDFARPTR typespecific_workarea;
  106.  
  107. #define LastSqr v[4].a
  108.  
  109. static char far * far ErrStrings[] = {   /* TIW 03-31-91 added far */
  110.    "Should be an Argument",
  111.    "Should be an Operator",
  112.    "')' needs a matching '('",
  113.    "Need more ')'",
  114.    "Undefined Operator",
  115.    "Undefined Function",
  116.    "More than one ','",
  117.    "Table overflow"
  118. };
  119.  
  120. unsigned SkipWhiteSpace(char *Str) {
  121.    unsigned n, Done;
  122.  
  123.    for(Done = n = 0; !Done; n++) {
  124.       switch(Str[n]) {
  125.          case ' ':
  126.          case '\t':
  127.          case '\n':
  128.          case '\r':
  129.             break;
  130.          default:
  131.             Done = 1;
  132.       }
  133.    }
  134.    return(n - 1);
  135. }
  136.  
  137. /* Random number code, MCP 11-21-91 */
  138.  
  139. unsigned long NewRandNum(void)
  140. {
  141.    return(RandNum = ((RandNum << 15) + rand15()) ^ RandNum);
  142. }
  143.  
  144. void lRandom(void)
  145. {
  146.    v[7].a.l.x = NewRandNum() >> (32 - bitshift);
  147.    v[7].a.l.y = NewRandNum() >> (32 - bitshift);
  148. }
  149.  
  150. void dRandom(void)
  151. {
  152.    long x, y;
  153.  
  154.    /* Use the same algorithm as for fixed math so that they will generate
  155.       the same fractals when the srand() function is used. */
  156.    x = NewRandNum() >> (32 - bitshift);
  157.    y = NewRandNum() >> (32 - bitshift);
  158.    v[7].a.d.x = ((double)x / (1L << bitshift));
  159.    v[7].a.d.y = ((double)y / (1L << bitshift));
  160. }
  161.  
  162. #ifndef XFRACT
  163. void mRandom(void)
  164. {
  165.    long x, y;
  166.  
  167.    /* Use the same algorithm as for fixed math so that they will generate
  168.       the same fractals when the srand() function is used. */
  169.    x = NewRandNum() >> (32 - bitshift);
  170.    y = NewRandNum() >> (32 - bitshift);
  171.    v[7].a.m.x = *fg2MP(x, bitshift);
  172.    v[7].a.m.y = *fg2MP(y, bitshift);
  173. }
  174. #endif
  175.  
  176. void SetRandFnct(void)
  177. {
  178.    unsigned Seed;
  179.  
  180.    if(!SetRandom)
  181.       RandNum = Arg1->l.x ^ Arg1->l.y;
  182.  
  183.    Seed = (unsigned)RandNum ^ (unsigned)(RandNum >> 16);
  184.    srand(Seed);
  185.    SetRandom = 1;
  186.  
  187.    /* Clear out the seed */
  188.    NewRandNum();
  189.    NewRandNum();
  190.    NewRandNum();
  191. }
  192.  
  193. void RandomSeed(void)
  194. {
  195.    time_t ltime;
  196.  
  197.    /* Use the current time to randomize the random number sequence. */
  198.    time(<ime);
  199.    srand((unsigned int)ltime);
  200.  
  201.    NewRandNum();
  202.    NewRandNum();
  203.    NewRandNum();
  204.    Randomized = 1;
  205. }
  206.  
  207. #ifndef XFRACT
  208. void lStkSRand(void)
  209. {
  210.    SetRandFnct();
  211.    lRandom();
  212.    Arg1->l = v[7].a.l;
  213. }
  214. #endif
  215.  
  216. #ifndef XFRACT
  217. void mStkSRand(void)
  218. {
  219.    Arg1->l.x = Arg1->m.x.Mant ^ (long)Arg1->m.x.Exp;
  220.    Arg1->l.y = Arg1->m.y.Mant ^ (long)Arg1->m.y.Exp;
  221.    SetRandFnct();
  222.    mRandom();
  223.    Arg1->m = v[7].a.m;
  224. }
  225. #endif
  226.  
  227. void dStkSRand(void)
  228. {
  229.    Arg1->l.x = (long)(Arg1->d.x * (1L << bitshift));
  230.    Arg1->l.y = (long)(Arg1->d.y * (1L << bitshift));
  231.    SetRandFnct();
  232.    dRandom();
  233.    Arg1->d = v[7].a.d;
  234. }
  235.  
  236. void (*StkSRand)(void) = dStkSRand;
  237.  
  238. void dStkAbs(void) {
  239.    Arg1->d.x = fabs(Arg1->d.x);
  240.    Arg1->d.y = fabs(Arg1->d.y);
  241. }
  242.  
  243. #ifndef XFRACT
  244. void mStkAbs(void) {
  245.    if(Arg1->m.x.Exp < 0)
  246.       Arg1->m.x.Exp = -Arg1->m.x.Exp;
  247.    if(Arg1->m.y.Exp < 0)
  248.       Arg1->m.y.Exp = -Arg1->m.y.Exp;
  249. }
  250.  
  251. void lStkAbs(void) {
  252.    Arg1->l.x = labs(Arg1->l.x);
  253.    Arg1->l.y = labs(Arg1->l.y);
  254. }
  255. #endif
  256.  
  257. void (*StkAbs)(void) = dStkAbs;
  258.  
  259. void dStkSqr(void) {
  260.    LastSqr.d.x = Arg1->d.x * Arg1->d.x;
  261.    LastSqr.d.y = Arg1->d.y * Arg1->d.y;
  262.    Arg1->d.y = Arg1->d.x * Arg1->d.y * 2.0;
  263.    Arg1->d.x = LastSqr.d.x - LastSqr.d.y;
  264.    LastSqr.d.x += LastSqr.d.y;
  265.    LastSqr.d.y = 0;
  266. }
  267.  
  268. #ifndef XFRACT
  269. void mStkSqr(void) {
  270.    LastSqr.m.x = *MPmul(Arg1->m.x, Arg1->m.x);
  271.    LastSqr.m.y = *MPmul(Arg1->m.y, Arg1->m.y);
  272.    Arg1->m.y = *MPmul(Arg1->m.x, Arg1->m.y);
  273.    Arg1->m.y.Exp++;
  274.    Arg1->m.x = *MPsub(LastSqr.m.x, LastSqr.m.y);
  275.    LastSqr.m.x = *MPadd(LastSqr.m.x, LastSqr.m.y);
  276.    LastSqr.m.y.Mant = (long)(LastSqr.m.y.Exp = 0);
  277. }
  278.  
  279. void lStkSqr(void) {
  280.    LastSqr.l.x = multiply(Arg1->l.x, Arg1->l.x, bitshift);
  281.    LastSqr.l.y = multiply(Arg1->l.y, Arg1->l.y, bitshift);
  282.    Arg1->l.y = multiply(Arg1->l.x, Arg1->l.y, bitshift) << 1;
  283.    Arg1->l.x = LastSqr.l.x - LastSqr.l.y;
  284.    LastSqr.l.x += LastSqr.l.y;
  285.    LastSqr.l.y = 0L;
  286. }
  287. #endif
  288.  
  289. void (*StkSqr)(void) = dStkSqr;
  290.  
  291. void dStkAdd(void) {
  292.    Arg2->d.x += Arg1->d.x;
  293.    Arg2->d.y += Arg1->d.y;
  294.    Arg1--;
  295.    Arg2--;
  296. }
  297.  
  298. #ifndef XFRACT
  299. void mStkAdd(void) {
  300.    Arg2->m = MPCadd(Arg2->m, Arg1->m);
  301.    Arg1--;
  302.    Arg2--;
  303. }
  304.  
  305. void lStkAdd(void) {
  306.    Arg2->l.x += Arg1->l.x;
  307.    Arg2->l.y += Arg1->l.y;
  308.    Arg1--;
  309.    Arg2--;
  310. }
  311. #endif
  312.  
  313. void (*StkAdd)(void) = dStkAdd;
  314.  
  315. void dStkSub(void) {
  316.    Arg2->d.x -= Arg1->d.x;
  317.    Arg2->d.y -= Arg1->d.y;
  318.    Arg1--;
  319.    Arg2--;
  320. }
  321.  
  322. #ifndef XFRACT
  323. void mStkSub(void) {
  324.    Arg2->m = MPCsub(Arg2->m, Arg1->m);
  325.    Arg1--;
  326.    Arg2--;
  327. }
  328.  
  329. void lStkSub(void) {
  330.    Arg2->l.x -= Arg1->l.x;
  331.    Arg2->l.y -= Arg1->l.y;
  332.    Arg1--;
  333.    Arg2--;
  334. }
  335. #endif
  336.  
  337. void (*StkSub)(void) = dStkSub;
  338.  
  339. void dStkConj(void) {
  340.    Arg1->d.y = -Arg1->d.y;
  341. }
  342.  
  343. #ifndef XFRACT
  344. void mStkConj(void) {
  345.    Arg1->m.y.Exp ^= 0x8000;
  346. }
  347.  
  348. void lStkConj(void) {
  349.    Arg1->l.y = -Arg1->l.y;
  350. }
  351. #endif
  352.  
  353. void (*StkConj)(void) = dStkConj;
  354.  
  355. void dStkReal(void) {
  356.    Arg1->d.y = 0.0;
  357. }
  358.  
  359. #ifndef XFRACT
  360. void mStkReal(void) {
  361.    Arg1->m.y.Mant = (long)(Arg1->m.y.Exp = 0);
  362. }
  363.  
  364. void lStkReal(void) {
  365.    Arg1->l.y = 0l;
  366. }
  367. #endif
  368.  
  369. void (*StkReal)(void) = dStkReal;
  370.  
  371. void dStkImag(void) {
  372.    Arg1->d.x = Arg1->d.y;
  373.    Arg1->d.y = 0.0;
  374. }
  375.  
  376. #ifndef XFRACT
  377. void mStkImag(void) {
  378.    Arg1->m.x = Arg1->m.y;
  379.    Arg1->m.y.Mant = (long)(Arg1->m.y.Exp = 0);
  380. }
  381.  
  382. void lStkImag(void) {
  383.    Arg1->l.x = Arg1->l